#-*- coding: utf-8 -*-

## This program is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 2 of the License, or
## (at your option) any later version.

## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
## GNU General Public License for more details.

## You should have received a copy of the GNU General Public License
## along with this program; if not, write to the Free Software
## Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

import os
import os.path
import logging

from ConfigParser import SafeConfigParser


default_config = ("[Pyragua]\n"
                  "mostrar_splash = True\n"
                  "")
# TODO: Realizar tests de prueba
class PyraguaConfigParser(SafeConfigParser):
    pass

config_parser = PyraguaConfigParser()
"La única instancia de configuración de todo Pyragua"

# TODO: Mejorar esta función, para que no use estos parámetros.
def init_config(path=[], arg=''):
    """Carga un archivo de configuración de acuerdo a los parámetros recibidos.

    Argumentos:
    path -- Lista de rutas a archivos de configuración.  Si es cadena vacía, trata de cargar
            valores por defecto.
    arg  -- Si es -q se ignora path y se carga la configuración por defecto.
            Si es -t se carga el archivo especificado en path.
            
    """
    if arg == '-q':  # Se cargan valores por defecto
        try:
            temp_config_file = os.tmpfile()
            temp_config_file.write(default_config)
            temp_config_file.seek(0)
        except IOError:
            logging.error('Incapaz de abrir archivo temporal')
            
        config_parser.readfp(temp_config_file)
        config_parser.arg = False
        temp_config_file.close()
        logging.info('Iniciando con configuración por defecto')
        return  # Retornar algún valor?
    if arg == '-t': # Si se tiene éxito, se debe terminar
        # En este caso se escribe la configuración al final, pero en el archivo
        # especificado
        try:
            config_file = open(path)
            config_parser.readfp(config_file)
            config_parser.path = path
            config_parser.arg = 'def_file'
            logging.info('Abriendo archivo de configuración %s', path)
            config_file.close()
            return  # Retornar algún valor?
        except IOError:
            logging.error('No se ha podido abrir el archivo %s', path)

    # 2. Buscar en la carpeta de Pyragua del usuario
    user_dir_path = os.path.join(os.path.expanduser("~"), '.pyragua')
    config_parser.path = os.path.join(user_dir_path, 'pyragua.conf')
    if not os.path.isdir(user_dir_path):
        try:
            logging.info('Creando el directorio de Pyragua')
            os.mkdir(user_dir_path)
            config_file = open(os.path.join(user_dir_path, 'pyragua.conf'), 'w')
            config_file.write(default_config)
            config_file.flush()
            config_file.close()
            print 'abriendo'
            config_file = open(os.path.join(user_dir_path, 'pyragua.conf'), 'r')

            print config_file.tell()
            print config_file
            config_parser.readfp(config_file)
            config_parser.close()
            return
        except OSError:
            logging.error('No se ha podido crear la carpeta '+os.path.join(user_dir_path, 'pyragua.conf'))
    else:
        config_path = os.path.join(user_dir_path, 'pyragua.conf')
        logging.info("Cargando archivo de configuración "+config_path)
        config_file = open(config_path)
        config_parser.readfp(config_file)
        config_file.close()
        return
    config_parser.arg = 'system'
    # 3. Buscar en la carpeta de Pyragua del Sistema.
    #    Se debe crear la carepta del usuario y el archivo.

    # 4. Usar la configuración por defecto.
    #    Se debe crear la carpeta del usuario y el archivo.


#Interfaz de SafeConfigParser
def defaults():
    pass

def sections():
    return config_parser.sections()

def add_section(section):
    pass

def has_section(section):
    pass

def options(section):
    pass

def has_option(section, option):
    pass

def read(filenames):
    pass

def readfp(fp, *args):
    pass

def get(section, option, default):
    """Trata de sacar el valor de la opción de la sección especificada.
    En caso de no poder retorna el valor enviado por defecto.

    section -- La sección en el archivo .INI.
    option -- La opción de la sección el archivo .INI.
    default -- El valor a retornar si no puede encontrar la sección.

    """
    try:
        return config_parser.get(section, option)
    except:
        return default

def getint(section, option, default):
    try:
        return config_parser.getint(section, option)
    except:
        return default


def getfloat(section, option, default):
    try:
        return config_parser.getfloat(section, option)
    except:
        return default

def getboolean(section, option):
    try:
        return config_parser.getboolean(section, option)
    except:
        return default

    pass

def items(section):
    pass

def set(section, option, value):
    config_parser.set(section, option, value)

def write(fileobj=None):
    """Escribe los cambios realizado en el archivo de configuración.

    """
    if fileobj:
        config_parser.write(fileobj)
    if not config_parser.arg:
        logging.info('Cargado con la opción "Sin configuración"')
        return
    if config_parser.arg == "del_file":
        try:
            file_ = open(config_parser.path, 'w')
            config_parser.write(file_)
        except:  # TODO: Manejar la excepción correspondiente
            logging.error("No se ha podido guardar la configuración en " +
                          config_parser.path)
            return
    try:
        file_ = open(config_parser.path)
        config_parser.write(file_)
    except:  # TODO: Manejar la excepción correspondiente
        logging.error("No se ha podido guardar la configuración")

def remove_option(section, option):
    pass

def remove_section(section):
    pass

#Decidir si soportar
def optionxform(option):
    pass
# Fin de interfaz de SafeConfigParser
